import { MessageType } from './types.js';
import { clearAuthData } from '../utils/storage.js';
import { showLogoutModal } from '../components/LogoutModal.js';

/**
 * WebSocket消息处理器
 */
export class MessageHandler {
  constructor(webSocketManager) {
    this.wsManager = webSocketManager;
    this.handlers = new Map();
    
    // 注册默认消息处理器
    this.registerDefaultHandlers();
  }

  /**
   * 注册默认消息处理器
   */
  registerDefaultHandlers() {
    this.handlers.set(MessageType.REGISTER_SUCCESS, this.handleRegisterSuccess.bind(this));
    this.handlers.set(MessageType.PONG, this.handlePong.bind(this));
    this.handlers.set(MessageType.FORCE_LOGOUT, this.handleForceLogout.bind(this));
    this.handlers.set(MessageType.CONNECTION_TIMEOUT, this.handleConnectionTimeout.bind(this));
    this.handlers.set(MessageType.ERROR, this.handleError.bind(this));
  }

  /**
   * 处理注册成功消息
   */
  handleRegisterSuccess(message) {
    console.log('WebSocket注册成功:', message);
    
    // 设置连接ID并启动心跳
    if (message.data && message.data.conn_id) {
      this.wsManager.setConnectionId(message.data.conn_id);
    } else {
      console.warn('注册成功消息缺少连接ID:', message);
      // 如果缺少连接ID，直接启动心跳作为备选方案
      this.wsManager.startHeartbeat();
    }
    
    // 触发注册成功回调
    if (this.wsManager.onRegisterSuccess) {
      this.wsManager.onRegisterSuccess(message.data);
    }
  }

  /**
   * 处理PONG响应
   */
  handlePong(message) {
    console.log('收到PONG响应:', message);
    this.wsManager.resetHeartbeat();
    
    // 触发PONG回调
    if (this.wsManager.onPong) {
      this.wsManager.onPong(message.data);
    }
  }

  /**
   * 处理强制下线消息
   */
  handleForceLogout(message) {
    console.warn('收到强制下线消息:', message);
    
    // 清除本地认证数据
    clearAuthData();
    
    // 关闭WebSocket连接
    this.wsManager.disconnect();
    
    // 显示下线提示
    this.showLogoutMessage(message.data?.message || '账号在其他设备登录，您已被强制下线');
    
    // 触发强制下线回调
    if (this.wsManager.onForceLogout) {
      this.wsManager.onForceLogout(message.data);
    }
  }

  /**
   * 处理连接超时
   */
  handleConnectionTimeout(message) {
    console.warn('连接超时:', message);
    this.wsManager.reconnect();
    
    // 触发连接超时回调
    if (this.wsManager.onConnectionTimeout) {
      this.wsManager.onConnectionTimeout(message.data);
    }
  }

  /**
   * 处理错误消息
   */
  handleError(message) {
    console.error('WebSocket错误:', message);
    
    // 触发错误回调
    if (this.wsManager.onError) {
      this.wsManager.onError(message.data);
    }
  }

  /**
   * 显示下线提示消息
   */
  showLogoutMessage(message) {
    // 使用原生模态框显示下线提示
    showLogoutModal(message, {
      onPasswordChange: () => {
        // 跳转到密码修改页面
        window.location.href = '/change-password';
      },
      onRelogin: () => {
        // 直接跳转到登录页
        window.location.href = '/login';
      },
      autoRedirect: true,
      redirectDelay: 3000
    });
  }

  /**
   * 处理接收到的消息
   */
  handleMessage(message) {
    try {
      const parsedMessage = typeof message === 'string' ? JSON.parse(message) : message;
      
      if (!parsedMessage || !parsedMessage.type) {
        console.warn('无效的WebSocket消息格式:', message);
        return;
      }

      const handler = this.handlers.get(parsedMessage.type);
      if (handler) {
        handler(parsedMessage);  // 传递完整的消息对象，而不仅仅是data部分
      } else {
        console.warn('未注册的消息类型处理器:', parsedMessage.type);
        
        // 触发未知消息回调
        if (this.wsManager.onUnknownMessage) {
          this.wsManager.onUnknownMessage(parsedMessage);
        }
      }
    } catch (error) {
      console.error('消息处理错误:', error, message);
      
      // 触发消息解析错误回调
      if (this.wsManager.onMessageParseError) {
        this.wsManager.onMessageParseError(error, message);
      }
    }
  }

  /**
   * 注册自定义消息处理器
   */
  registerHandler(messageType, handler) {
    if (typeof handler === 'function') {
      this.handlers.set(messageType, handler.bind(this));
    } else {
      console.warn('无效的消息处理器:', handler);
    }
  }

  /**
   * 移除消息处理器
   */
  removeHandler(messageType) {
    this.handlers.delete(messageType);
  }
}

export default MessageHandler;
